home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / incl / LEDA / basic.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-05  |  21.8 KB  |  799 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  basic.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #ifndef LEDA_BASIC_H
  17. #define LEDA_BASIC_H
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21.  
  22.  
  23. //------------------------------------------------------------------------------
  24. // compiler/system dependent definitions and includes
  25. //------------------------------------------------------------------------------
  26.  
  27. #if defined(_SGI_) || defined(__sgi)
  28. /* random() declared in math.h */
  29. #include <math.h>
  30. #endif
  31.  
  32.  
  33. #if defined(__GNUG__)
  34. /* no random() function in libg++ (since version 2.5) */
  35. #define __NO_RANDOM__
  36. #if __GNUC_MINOR__ > 5
  37. #define __BUILTIN_BOOL__
  38. #endif
  39. #endif
  40.  
  41.  
  42. #if defined(__ZTC__)
  43. #define __MSDOS__
  44. #define __NO_RANDOM__
  45. #define MAXINT          (int(0x7FFFFFFF))
  46. #define MAXFLOAT    (float(3.37E+38))
  47. #define MAXDOUBLE       (double(1.797693E+308))
  48. #include <iostream.hpp>
  49. #else
  50. #include <values.h>
  51. #include <iostream.h>
  52. #endif
  53.  
  54.  
  55. #if defined(__TURBOC__)
  56. #define __NO_RANDOM__
  57. #define FRIEND_INLINE friend
  58. #else
  59. #define _CLASSTYPE
  60. #define FRIEND_INLINE friend inline
  61. #endif
  62.  
  63.  
  64.  
  65. //------------------------------------------------------------------------------
  66. // Global Types
  67. //------------------------------------------------------------------------------
  68.  
  69. typedef void* GenPtr;    // generic pointer type
  70.  
  71. typedef int  (*CMP_PTR)(GenPtr&,GenPtr&);
  72. typedef void (*APP_PTR)(GenPtr&);
  73. typedef int  (*ORD_PTR)(GenPtr&);
  74.  
  75.  
  76.  
  77. //------------------------------------------------------------------------------
  78. // Error Handling
  79. //------------------------------------------------------------------------------
  80.  
  81. typedef void (*PEH)(int,const char*);   // Pointer to Error Handler
  82.  
  83. extern PEH  p_error_handler;
  84. extern PEH  set_error_handler(PEH);
  85. extern void default_error_handler(int,const char*);
  86. inline void error_handler(int i, const char* s)  { p_error_handler(i,s); }
  87.  
  88.  
  89. //------------------------------------------------------------------------------
  90. // Templates
  91. //------------------------------------------------------------------------------
  92.  
  93. #include <LEDA/template.h>
  94.  
  95.  
  96. //------------------------------------------------------------------------------
  97. // LEDA INIT
  98. //------------------------------------------------------------------------------
  99.  
  100.  
  101. struct LEDA {
  102.  
  103.  LEDA();
  104. ~LEDA();
  105.  
  106. char* init_list;
  107. static const char* version_string;
  108. static int loop_dummy;
  109. };
  110.  
  111. extern LEDA L_E_D_A;
  112.  
  113.  
  114. //------------------------------------------------------------------------------
  115. // Memory Management
  116. //------------------------------------------------------------------------------
  117.  
  118. struct  memory_elem_type { memory_elem_type* next; };
  119. typedef memory_elem_type* memory_elem_ptr;
  120.  
  121. extern memory_elem_ptr memory_free_list[];
  122.  
  123. extern memory_elem_ptr memory_allocate_block(int);
  124. extern memory_elem_ptr allocate_bytes(int);
  125. extern memory_elem_ptr allocate_bytes_with_check(int);
  126. extern memory_elem_ptr allocate_words(int);
  127.  
  128. extern void deallocate_bytes(void*,int);
  129. extern void deallocate_bytes_with_check(void*,int);
  130. extern void deallocate_words(void*,int);
  131. extern void memory_clear();
  132. extern void memory_kill();
  133. extern void print_statistics();
  134.  
  135. extern int used_memory();
  136.  
  137. inline void deallocate_list(void* head,void* tail, int bytes)
  138. { memory_elem_ptr(tail)->next = memory_free_list[bytes];
  139.   memory_free_list[bytes] = memory_elem_ptr(head);
  140.  }
  141.  
  142. #define OPERATOR_NEW(bytes)\
  143. void* operator new(size_t)\
  144. { memory_elem_ptr* q = memory_free_list+bytes;\
  145.   if (*q==0) *q = memory_allocate_block(bytes);\
  146.   memory_elem_ptr p = *q;\
  147.   *q = p->next;\
  148.   return p;\
  149.  }
  150.  
  151. #define OPERATOR_DEL(bytes)\
  152. void  operator delete(void* p)\
  153. { memory_elem_ptr* q = memory_free_list+bytes;\
  154.   memory_elem_ptr(p)->next = *q;\
  155.   *q = memory_elem_ptr(p);\
  156.  }
  157.  
  158. #define OPERATOR_NEW_WITH_CHECK(bytes)\
  159. void* operator new(size_t) { return allocate_bytes_with_check(bytes); }
  160.  
  161. #define OPERATOR_DEL_WITH_CHECK(bytes)\
  162. void  operator delete(void* p) { deallocate_bytes_with_check(p,bytes); }
  163.  
  164.  
  165. #define LEDA_MEMORY(type)\
  166. OPERATOR_NEW(sizeof(type))\
  167. OPERATOR_DEL(sizeof(type))
  168.  
  169. #define LEDA_MEMORY_WITH_CHECK(type)\
  170. OPERATOR_NEW_WITH_CHECK(sizeof(type))\
  171. OPERATOR_DEL_WITH_CHECK(sizeof(type))
  172.  
  173.  
  174. //------------------------------------------------------------------------------
  175. // handle_base/rep: base classes for handle types string, point, segment,...
  176. //------------------------------------------------------------------------------
  177.  
  178.  
  179. class handle_rep  {
  180.  
  181. friend class handle_base;
  182.   
  183. protected:
  184.  
  185.    int  count;
  186.    
  187.          handle_rep()  { count = 1; }
  188. virtual ~handle_rep()  {}
  189.  
  190. LEDA_MEMORY(handle_rep);
  191.   
  192. };
  193.  
  194.  
  195. class handle_base {
  196.  
  197. protected:
  198.  
  199. handle_rep* PTR;
  200.  
  201. public:
  202.  
  203.  handle_base()                     {}
  204.  handle_base(const handle_base& x) { PTR = x.PTR;  PTR->count++; }
  205.  
  206. ~handle_base()                     {}
  207.  
  208.  
  209. handle_base& operator=(const handle_base& x)
  210. { x.PTR->count++;
  211.   if (--PTR->count == 0)  delete PTR;
  212.   PTR = x.PTR;
  213.   return *this;
  214.  }
  215.  
  216. public:
  217.  
  218. void clear()        { if (--(PTR->count)==0) delete PTR; }
  219. GenPtr copy() const { PTR->count++; return PTR; }
  220.  
  221.  
  222. FRIEND_INLINE int    compare(const handle_base&, const handle_base&);
  223. FRIEND_INLINE void   Print(const handle_base&, ostream& = cout);
  224. FRIEND_INLINE void   Read(handle_base&, istream& = cin);
  225. FRIEND_INLINE void   Init(handle_base&);
  226. FRIEND_INLINE void   Clear(handle_base&);
  227. FRIEND_INLINE GenPtr Copy(handle_base&);
  228. FRIEND_INLINE GenPtr Convert(const handle_base&);
  229.  
  230. };
  231.  
  232. inline int compare(const handle_base&, const handle_base&)
  233. { error_handler(1,"compare undefined"); 
  234.   return 0; }
  235.  
  236. inline void Print(const handle_base&, ostream&)
  237. { error_handler(1,"Print undefined");  }
  238.  
  239. inline void Read(handle_base&, istream&)
  240. { error_handler(1,"Read undefined");  }
  241.  
  242.  
  243. inline void   Init(handle_base&)            {}
  244. inline void   Clear(handle_base& y)         { y.clear(); }
  245. inline GenPtr Copy(handle_base& y)          { return y.copy();}
  246. inline GenPtr Convert(const handle_base& y) { return y.PTR; }
  247.  
  248.  
  249.  
  250.  
  251. #define LEDA_HANDLE_TYPE(type)\
  252. inline void   Clear(type& y)  { y.clear(); }\
  253. inline GenPtr Copy(type& y)   { return y.copy();}\
  254. inline char*  Type_Name(const type*) { return STRINGIZE(type); }
  255.  
  256.  
  257.  
  258. //------------------------------------------------------------------------------
  259. // compare, Print, Read, Init, Copy, Clear, Convert, ...  for built-in types
  260. //------------------------------------------------------------------------------
  261.  
  262. // defining a linear order
  263.  
  264. inline int compare(const GenPtr& x, const GenPtr& y) 
  265. { return (char*)x-(char*)y; }
  266.  
  267. inline int compare(const char& x, const char& y)     { return x-y; }
  268.  
  269. inline int compare(const int& x, const int& y)
  270. { if (x < y)  return -1; 
  271.   else if (x > y)  return  1; 
  272.   else return 0;
  273. }
  274.  
  275. inline int compare(const long& x, const long& y)
  276. { if (x < y)  return -1; 
  277.   else if (x > y)  return  1; 
  278.   else return 0;
  279. }
  280.  
  281. inline int compare(const double& x, const double& y)
  282. { if (x < y)  return -1; 
  283.   else if (x > y)  return  1; 
  284.   else return 0;
  285. }
  286.  
  287. inline int compare(const float& x, const float& y)
  288. { if (x < y)  return -1; 
  289.   else if (x > y)  return  1; 
  290.   else return 0;
  291. }
  292.  
  293.  
  294. // stream output
  295.  
  296. inline void Print(const GenPtr& x, ostream& out = cout) { out << x; }
  297. inline void Print(const char& x, ostream& out = cout)   { out << x; }
  298. inline void Print(const short& x, ostream& out = cout)  { out << x; }
  299. inline void Print(const int& x, ostream& out = cout)    { out << x; }
  300. inline void Print(const long& x, ostream& out = cout)   { out << x; }
  301. inline void Print(const float& x, ostream& out = cout)  { out << x; }
  302. inline void Print(const double& x, ostream& out = cout) { out << x; }
  303.  
  304. // stream input
  305.  
  306. inline istream& operator>>(istream& in, GenPtr)     { return in; }
  307.  
  308. inline void Read(GenPtr,   istream&)          {}
  309. inline void Read(char& x,  istream& in = cin) { in >> x; }
  310. inline void Read(short& x, istream& in = cin) { in >> x; }
  311. inline void Read(int&  x,  istream& in = cin) { in >> x; }
  312. inline void Read(long& x,  istream& in = cin) { in >> x; }
  313. inline void Read(float& x, istream& in = cin) { in >> x;}
  314. inline void Read(double& x,istream& in = cin) { in >> x;}
  315.  
  316.  
  317. // initialization
  318.  
  319. inline void Init(const GenPtr&) {}
  320. inline void Init(char&   x) { x=0; }
  321. inline void Init(short&  x) { x=0; }
  322. inline void Init(int&    x) { x=0; }
  323. inline void Init(long&   x) { x=0; }
  324. inline void Init(float&  x) { x=0; }
  325. inline void Init(double& x) { x=0; }
  326.  
  327.  
  328. // destruction
  329.  
  330. inline void Clear(const GenPtr&) {}
  331. inline void Clear(char&  )    {}
  332. inline void Clear(short& )    {}
  333. inline void Clear(int&   )    {}
  334. inline void Clear(long&  )    {}
  335. inline void Clear(float& )    {}
  336. inline void Clear(double& x) { deallocate_bytes(&x,sizeof(double)); }
  337.  
  338.  
  339. // copying
  340.  
  341. inline GenPtr Copy(GenPtr x)  { return x; }
  342. inline GenPtr Copy(char x)    { GenPtr p; *((char*)&p) =x; return p; }
  343. inline GenPtr Copy(short x)   { GenPtr p; *((short*)&p)=x; return p; }
  344. inline GenPtr Copy(int  x)    { return *(GenPtr*)&x; }
  345. inline GenPtr Copy(long x)    { return *(GenPtr*)&x; }
  346. inline GenPtr Copy(float x)   { return *(GenPtr*)&x; }
  347. inline GenPtr Copy(double x)
  348. { double* p = (double*)allocate_bytes(sizeof(double));
  349.   *p = x;
  350.   return p;
  351.  }
  352.  
  353.  
  354. // converting to a generic pointer
  355.  
  356. inline GenPtr Convert(GenPtr x)     { return x; }
  357. inline GenPtr Convert(char  x)      { GenPtr p; *((char*)&p) =x; return p; }
  358. inline GenPtr Convert(short x)      { GenPtr p; *((short*)&p)=x; return p; }
  359. inline GenPtr Convert(int   x)      { return GenPtr(x); }
  360. inline GenPtr Convert(long  x)      { return GenPtr(x); }
  361. inline GenPtr Convert(float x)      { return *(GenPtr*)&x; }
  362. inline GenPtr Convert(double& x)    { return GenPtr(&x); }
  363.  
  364.  
  365.  
  366. #if !defined(__TEMPLATE_FUNCTIONS__)
  367.  
  368. // access through a generic pointer
  369.  
  370. inline const GenPtr& Access(const GenPtr, const GenPtr& p) { return p; }
  371. inline double& Access(const double*, GenPtr p){ return *(double*)p;  }
  372.  
  373. #endif
  374.  
  375.  
  376. // integer type or not ?
  377.  
  378. inline int Int_Type(GenPtr) { return 0; }
  379. inline int Int_Type(const int*)   { return 1; }
  380. inline int Int_Type(const long*)  { return 1; }
  381.  
  382.  
  383. // name of types
  384.  
  385. inline char* Type_Name(const GenPtr)     { return "unknown"; }
  386. inline char* Type_Name(const char*  )    { return "char"; }
  387. inline char* Type_Name(const short* )    { return "short"; }
  388. inline char* Type_Name(const int*   )    { return "int"; }
  389. inline char* Type_Name(const long*  )    { return "long"; }
  390. inline char* Type_Name(const float* )    { return "float"; }
  391. inline char* Type_Name(const double*)    { return "double"; }
  392.  
  393.  
  394. #if defined(__BUILTIN_BOOL__)
  395. inline GenPtr Convert(bool  x)        { GenPtr p; *((bool*)&p)=x; return p; }
  396. inline GenPtr Copy(bool  x)           { GenPtr p; *((bool*)&p)=x; return p; }
  397. inline void   Clear(bool& x)          { x=false; }
  398. inline bool&  Access(const bool*, const GenPtr& p) { return *(bool*)&p; }
  399. inline void   Init(bool& x)           { x=false; }
  400. inline char*  Type_Name(const bool*)  { return "bool"; }
  401.  
  402. inline int  compare(const bool& x, const bool& y) { return char(x)-char(y); }
  403. inline void Print(const bool& x, ostream& out) { out << (x ? "true":"false"); }
  404. inline void Read(bool&,  istream&) {}
  405. #endif
  406.  
  407.  
  408.  
  409. // maximal and minimal values for some numerical types
  410.  
  411. inline int    Max_Value(int& x)     { return x =  MAXINT;   }
  412. inline int    Min_Value(int& x)     { return x = -MAXINT;   }
  413. inline float  Max_Value(float& x)   { return x =  MAXFLOAT; }
  414. inline float  Min_Value(float& x)   { return x = -MAXFLOAT; }
  415. inline double Max_Value(double& x)  { return x =  MAXDOUBLE;}
  416. inline double Min_Value(double& x)  { return x = -MAXDOUBLE;}
  417.  
  418.  
  419. /*
  420.   type arguments for the LEDA_TYPE_PARAMETER macro must define:
  421.  
  422.   a constructor taking no arguments: type::type()
  423.   a copy constructor:                type::type(const type&)
  424.   a Read function:                   void Read(type&, istream&)
  425.   a Print function:                  void Print(const type&, ostream&)
  426.   a compare function:                int compare(const type&, const type&)
  427.  
  428. */
  429.  
  430. #define LEDA_TYPE_PARAMETER(type)\
  431. inline void   Init(type&)                        {}\
  432. inline void   Clear(type& x)                     { delete (type*)&x; }\
  433. inline GenPtr Copy(type& x)                      { return new type(x);}\
  434. inline GenPtr Convert(type& x)                   { return GenPtr(&x);}\
  435. inline type&  Access(const type*, GenPtr p)      { return *(type*)p; }\
  436. inline char*  Type_Name(const type*)             { return STRINGIZE(type); }
  437.  
  438.  
  439. #define DEFINE_LINEAR_ORDER(type,cmp,new_type)\
  440. struct new_type : public type\
  441. { new_type(type s)            : type(s) {}\
  442.   new_type(const new_type& s) : type(s) {}\
  443.   new_type() {}\
  444.  ~new_type() {}\
  445. };\
  446. inline int compare(const new_type& x, const new_type& y) { return cmp(x,y); }
  447.  
  448.  
  449. //------------------------------------------------------------------------------
  450. // Macros
  451. //------------------------------------------------------------------------------
  452.  
  453. // nil pointer
  454.  
  455. #define nil 0
  456.  
  457.  
  458. // ACCESS(T,x): access a reference of type T through a generic pointer p
  459. // we have to create a dummy first argument of type T* for Access(T*,x)
  460.  
  461.  
  462.  
  463. #if defined(__TEMPLATE_FUNCTIONS__)
  464. #define ACCESS(type,x)  Access((type*)0,x)
  465. #else
  466. #define ACCESS(type,x)  (type&)(Access((type*)0,x))
  467. #endif
  468.  
  469.  
  470. #define INT_TYPE(type)  Int_Type((type*)0)
  471. #define TYPE_NAME(type) Type_Name((type*)0)
  472.  
  473.  
  474. //turning a macro argument into a string
  475.  
  476. #if defined(__STDC__)  || defined(__MSDOS__)
  477. #define STRINGIZE(x) #x
  478. #else
  479. #define STRINGIZE(x) "x"
  480. #endif
  481.  
  482.  
  483. // ITERATION MACROS
  484.  
  485. #define forall_items(x,S) for(x = (S).first_item(); x; x = (S).next_item(x) )
  486.  
  487.  
  488.  
  489.  
  490. // To avoid multiple declarations of the "forall_loop_item" variable
  491. // we use a dummy for-loop to create a new block for it.
  492. // This, however, does not work with all compilers (ztc,lucid ...)
  493. // and we have to use the old forall mechanism (no nesting).
  494.  
  495. #if defined(__ZTC__) || defined(__lucid)
  496.  
  497. #define forall(x,S)\
  498. for((S).start_iteration(); (S).read_iterator(x); (S).move_to_succ())
  499.  
  500. #define Forall(x,S)\
  501. for((S).Start_iteration(); (S).read_iterator(x); (S).move_to_pred())
  502.  
  503. #else
  504.  
  505. #define forall(x,S)\
  506. for(LEDA::loop_dummy=0; LEDA::loop_dummy<1; LEDA::loop_dummy++)\
  507. for(GenPtr forall_loop_item=(S).first_item();\
  508. (S).forall_loop_test(forall_loop_item,x);\
  509. (S).loop_to_succ(forall_loop_item))
  510.  
  511. #define Forall(x,S)\
  512. for(LEDA::loop_dummy=0; LEDA::loop_dummy<1; LEDA::loop_dummy++)\
  513. for(GenPtr forall_loop_item=(S).last_item();\
  514. (S).forall_loop_test(forall_loop_item,x);\
  515. (S).loop_to_pred(forall_loop_item))
  516.  
  517. #endif
  518.  
  519.  
  520.  
  521.  
  522.  
  523. // miscellaneous
  524.  
  525. #define Main            main(int argc, char** argv)
  526. #define newline         cout << endl
  527. #define forever         for(;;)
  528. #define loop(a,b,c)     for (a=b;a<=c;a++)
  529.  
  530. #define Max(a,b) ( (a>b) ? a : b )
  531. #define Min(a,b) ( (a>b) ? b : a )
  532.  
  533.  
  534.  
  535. //------------------------------------------------------------------------------
  536. // enumerations
  537. //------------------------------------------------------------------------------
  538.  
  539. enum rel_pos { before = 1, after = 0 };
  540.  
  541. enum direction { forward = 0, backward = 1 };
  542.  
  543.  
  544. //------------------------------------------------------------------------------
  545. // boolean
  546. //------------------------------------------------------------------------------
  547.  
  548. #if !defined(__BUILTIN_BOOL__)
  549.  
  550. typedef char bool;
  551.  
  552. enum {false=0, true=1};
  553.  
  554. #endif
  555.  
  556.  
  557.  
  558. //------------------------------------------------------------------------------
  559. // strings
  560. //------------------------------------------------------------------------------
  561.  
  562. class string_rep : public handle_rep {
  563.  
  564. friend class string;
  565.  
  566.       char*   s;
  567.  
  568. int dummy;
  569.  
  570.  string_rep(const char*);
  571.  string_rep(char);
  572.  
  573. ~string_rep() { delete[] s; }
  574.  
  575.  LEDA_MEMORY(string_rep)
  576.  
  577. };
  578.  
  579.  
  580. class format_string  // used in string constructor (see below)
  581. { friend class string;
  582.   const char* str;
  583.   public:
  584.   format_string(const char* s) { str = s; }
  585. };
  586.  
  587.  
  588. class string  : public handle_base
  589. {
  590.  
  591.  friend class string_rep;
  592.  
  593.  friend class panel;
  594.  
  595.  static char* str_dup(const char*);
  596.  static char* str_cat(const char*,const char*);
  597.  static char* str_ncat(int, char**);
  598.  
  599.  string_rep*  ptr() const { return (string_rep*)PTR; }
  600.  
  601.  char** access_ptr() { return &(ptr()->s); }   // used by panel::string_item
  602.  
  603. public:
  604.  
  605.  string()                { PTR = new string_rep(""); }
  606.  string(char c)          { PTR = new string_rep(c);  }
  607.  
  608. //
  609. // string(const char*);
  610. // string(const char*, ...); // printf-like constructor
  611. //
  612. // That's what we want, but then (ARM page 326) a call string("xyz") is
  613. // ambiguous. We use the dummy class "format_string" to resolve  the
  614. // ambiguity:
  615. //
  616. // string(const char*);
  617. // string(format_string, ...);
  618. //
  619. // However, cfront's stdarg (on sparcs) cannot handle the case correctly
  620. // where the first argument is a class object (like format_string). In this
  621. // case we define constructors for each possible second argument and
  622. // we end up with :
  623.  
  624.  string(const char* s)       { PTR = new string_rep(s);}
  625.  
  626.  
  627. #if defined(__GNUG__) || defined(__lucid) || !defined(sparc)
  628.  string(format_string, ...);
  629. #else
  630.  string(const char*, int,   ...);
  631.  string(const char*, long,  ...);
  632.  string(const char*, float, ...);
  633.  string(const char*, double,...);
  634.  string(const char*, char*, ...);
  635.  string(const char*, void*, ...);
  636. #endif
  637.  
  638.  
  639.  string(int argc, char** argv) { PTR = new string_rep(str_ncat(argc,argv)); }
  640.  
  641.  string(const string& x) : handle_base(x)  {}
  642.  
  643. ~string() { clear(); }
  644.  
  645. string& operator=(const string& x) { handle_base::operator=(x); return *this; }
  646.  
  647. char*    operator~()   const { return str_dup(ptr()->s); }   // makes a copy !
  648. char*    cstring()     const { return ptr()->s; }
  649. operator const char*() const { return ptr()->s; }
  650.  
  651. int    length()          const;
  652. string sub(int,int)      const;
  653. int    pos(string,int=0) const;
  654.  
  655. string operator()(int i, int j)  const { return sub(i,j); }
  656. string head(int i)               const { return sub(0,i-1); }
  657. string tail(int i)               const { return sub(length()-i,length()-1); }
  658.  
  659. string insert(string, int=0)     const;
  660. string insert(int, string)       const;
  661.  
  662. string replace(const string&, const string&, int=1) const;
  663. string replace(int, int, const string&) const;
  664.  
  665. string del(const string&, int=1) const;
  666. string del(int, int) const;
  667.  
  668. void   read(istream&, char delim=' ');
  669. void   read(char delim=' ')           { read(cin,delim); }
  670. void   read_line(istream& I = cin)    { read(I,'\n'); }
  671.  
  672. string replace_all(const string& s1, const string& s2)
  673.                                          const  { return replace(s1,s2,0); }
  674. string replace(int i, const string& s)   const  { return replace(i,i,s);  }
  675.  
  676. string del_all(const string& s)          const  { return del(s,0); }
  677. string del(int i)                        const  { return del(i,i); } 
  678.  
  679. string format(string) const;
  680.  
  681. char  operator[](int) const;
  682. char& operator[](int);
  683.  
  684. string  operator+(const string& x)  const;
  685. string  operator+(const char* x)  const;
  686. string& operator+=(const string& x);
  687.  
  688. friend int operator==(const string& x, const string& y);
  689. friend int operator==(const string& x, const char* y);
  690. friend int operator!=(const string& x, const string& y);
  691. friend int operator!=(const string& x, const char* y);
  692. friend int operator< (const string& x, const string& y);
  693. friend int operator> (const string& x, const string& y);
  694. friend int operator<=(const string& x, const string& y);
  695. friend int operator>=(const string& x, const string& y);
  696.  
  697. friend istream& operator>>(istream&, string&);
  698. friend ostream& operator<<(ostream&, const string&) ;
  699.  
  700. };
  701.  
  702. inline void Print(const string& x, ostream& out)      { out << x; }
  703. inline void Read(string& x, istream& in)              { in  >> x; }
  704. extern int compare(const string& x, const string& y);
  705.  
  706. LEDA_HANDLE_TYPE(string)
  707.  
  708.  
  709.  
  710. //------------------------------------------------------------------------------
  711. // INT<cmp>: int with user defined linear order cmp
  712. //------------------------------------------------------------------------------
  713.  
  714. typedef int   (*CMP_INT_TYPE)(int,int);
  715.  
  716.  
  717. template<CMP_INT_TYPE cmp>
  718.  
  719. class _CLASSTYPE INT
  720. {int p;
  721.  
  722. public:
  723.  INT(const int i=0) { p = i;}
  724.  operator int()     { return p; }
  725.  
  726. FRIEND_INLINE void Print(const INT<cmp>& x, ostream& out = cout) { out << x.p; }
  727. FRIEND_INLINE void Read(INT<cmp>&  x, istream& in = cin)  { in  >> x.p; }
  728. FRIEND_INLINE void Init(INT<cmp>&  x)            { x.p=0; }
  729. FRIEND_INLINE GenPtr Copy(const INT<cmp>& x)     { return GenPtr(x); }
  730. FRIEND_INLINE void Clear(INT<cmp>& x)            { x.p = 0; }
  731. FRIEND_INLINE GenPtr Convert(const INT<cmp>& x)  { return GenPtr(x.p); }
  732. FRIEND_INLINE INT<cmp>& Access(INT<cmp>*,const GenPtr& p) { return *(INT<cmp>*)&p; }
  733.  
  734. FRIEND_INLINE int compare(const INT<cmp>& x, const INT<cmp>& y) { return cmp(x.p,y.p);}
  735. };
  736.  
  737.  
  738.  
  739. //------------------------------------------------------------------------------
  740. // random numbers, timing, etc.
  741. //------------------------------------------------------------------------------
  742.  
  743. #if defined(random)
  744. // if random is a macro undefine it
  745. #undef random
  746. #endif
  747.  
  748.  
  749. #if defined (__NO_RANDOM__)
  750. // the following two functions are defined in basic/_random.c
  751. extern int leda_random();
  752. extern void leda_srandom(int);
  753. inline int random()  { return leda_random(); }
  754. inline void srandom(int s) { leda_srandom(s); }
  755. #endif
  756.  
  757. inline int      random(int a, int b)  { return a + random()%(b-a+1); }
  758. inline double   rrandom() { return double(random())/MAXINT; }
  759. inline unsigned urandom(unsigned a, unsigned b) 
  760. { return a + (unsigned)(random())%(b-a+1); }
  761.  
  762. extern void init_random(int=0);
  763.  
  764. extern float used_time();
  765. extern float used_time(float&);
  766. extern void  print_time(string s);
  767. inline void  print_time() { print_time(""); }
  768. extern void  wait(unsigned int seconds);
  769.  
  770.  
  771. typedef int (*LEDA_SIG_PF) (...);
  772.  
  773. extern LEDA_SIG_PF catch_interrupts(LEDA_SIG_PF handler = nil);
  774.  
  775.  
  776. //------------------------------------------------------------------------------
  777. // input/output
  778. //------------------------------------------------------------------------------
  779.  
  780. extern int    Yes(string);
  781. extern int    Yes();
  782.  
  783. extern int    read_int(string);
  784. extern int    read_int();
  785.  
  786. extern char   read_char(string);
  787. extern char   read_char();
  788.  
  789. extern double read_real(string);
  790. extern double read_real();
  791.  
  792. extern string read_line(istream& =cin);
  793. extern string read_string(string);
  794. extern string read_string();
  795.  
  796. extern void skip_line(istream& =cin);
  797.  
  798. #endif
  799.